/**
 * 通用网络请求
 * 基于 Promise 响应拦截
 */

import store from '../../store';

export default {
    config: {
        baseUrl: 'http://39.108.60.14:10039',
        // baseUrl: 'http://192.168.2.229:8080',
        // baseUrl: 'http://192.168.2.79:8080',
        header: {
            'Content-Type': 'application/json;charset=UTF-8',
            // 'Content-Type':'application/x-www-form-urlencoded'
        },
        data: {},
        method: 'GET',
        dataType: 'json',
        responseType: 'text',
        success() {},
        fail() {},
        complete() {},
    },
    interceptor: {
        request: null,
        response: null,
    },
    request(options) {
        if (!options) {
            options = {};
        }
        options.baseUrl = options.baseUrl || this.config.baseUrl;
        options.dataType = options.dataType || this.config.dataType;
        options.url = options.baseUrl + options.url;
        options.data = options.data || {};
        options.method = options.method || this.config.method;
        //TODO 加密数据

        //TODO 数据签名
        try {
            const value = uni.getStorageSync('STOREKEY_LOGIN');
            if (value) {
                const _token = { 'x-app-token': value || 'undefined' };
                options.header = Object.assign({}, options.header, _token);
            }
        } catch (e) {
            // error
        }

        return new Promise((resolve, reject) => {
            let _config = null;

            options.complete = response => {
                let statusCode = response.statusCode;
                response.config = _config;
                if (process.env.NODE_ENV === 'development') {
                    if (statusCode === 200) {
                        console.log(
                            '【' +
                                _config.requestId +
                                '】 结果：' +
                                JSON.stringify(response.data),
                        );
                    }
                }
                if (this.interceptor.response) {
                    let newResponse = this.interceptor.response(response);
                    if (newResponse) {
                        response = newResponse;
                    }
                }
                // 统一的响应日志记录
                _reslog(response);
                if (statusCode === 200) {
                    //成功
                    resolve(response);
                } else {
                    uni.showToast({
                        title: '网络异常',
                        icon: 'none',
                    });
                    uni.stopPullDownRefresh();
                    reject(response);
                }
            };

            _config = Object.assign({}, this.config, options);
            _config.requestId = new Date().getTime();

            if (this.interceptor.request) {
                this.interceptor.request(_config);
            }

            // 统一的请求日志记录
            _reqlog(_config);

            if (process.env.NODE_ENV === 'development') {
                console.log(
                    '【' + _config.requestId + '】 地址：' + _config.url,
                );
                if (_config.data) {
                    console.log(
                        '【' +
                            _config.requestId +
                            '】 参数：' +
                            JSON.stringify(_config.data),
                    );
                }
            }

            uni.request(_config);
        });
    },
    get(url, data, options) {
        if (!options) {
            options = {};
        }
        options.url = url;
        options.data = data;
        options.method = 'GET';
        return this.request(options);
    },
    post(url, data, options) {
        if (!options) {
            options = {};
        }
        options.url = url;
        options.data = data;
        options.method = 'POST';
        return this.request(options);
    },
    put(url, data, options) {
        if (!options) {
            options = {};
        }
        options.url = url;
        options.data = data;
        options.method = 'PUT';
        return this.request(options);
    },
    delete(url, data, options) {
        if (!options) {
            options = {};
        }
        options.url = url;
        options.data = data;
        options.method = 'DELETE';
        return this.request(options);
    },
};

/**
 * 请求接口日志记录
 */
function _reqlog(req) {
    if (process.env.NODE_ENV === 'development') {
        console.log('【' + req.requestId + '】 地址：' + req.url);
        if (req.data) {
            console.log(
                '【' +
                    req.requestId +
                    '】 请求参数：' +
                    JSON.stringify(req.data),
            );
        }
    }
    //TODO 调接口异步写入日志数据库
}

/**
 * 响应接口日志记录
 */
function _reslog(res) {
    let _statusCode = '';
    if (res.statusCode) {
        _statusCode = res.data.errCode;
    }
    if (process.env.NODE_ENV === 'development') {
        console.log('【' + res.config.requestId + '】 地址：' + res.config.url);
        if (res.config.data) {
            console.log(
                '【' +
                    res.config.requestId +
                    '】 请求参数：' +
                    JSON.stringify(res.config.data),
            );
        }
        console.log(
            '【' + res.config.requestId + '】 响应结果：' + JSON.stringify(res),
        );
    }
    //TODO 除了接口服务错误外，其他日志调接口异步写入日志数据库
    switch (_statusCode) {
        case 200:
            break;
        case 401:
            uni.showToast({
                title: '登录过期，请重新登录！',
                icon: 'none',
            });
            uni.reLaunch({
                url: '/pages/user/login/index',
            });
            return;
        case 404:
            break;
        default:
            break;
    }
}
